// 实现文件存储子服务
// 1. 实现文件 RPC 服务类 --- 处理文件存储相关的业务逻辑
// 2. 实现文件存储子服务的服务器类
// 3. 实现文件存储子服务类的构造者

#include <brpc/server.h>
#include <butil/logging.h>

#include "etcd.hpp"     // 服务注册模块封装
#include "utils.hpp"   // 日志模块封装
#include "base.pb.h"
#include "file.pb.h"

namespace mag {

// 文件存储服务的实现类，继承自 mag::FileService
// 主要职责：处理客户端发送的请求
class FileServiceImpl : public mag::FileService {
    public:
        // 构造函数，初始化文件存储路径
        FileServiceImpl(const std::string &storage_path):
            _storage_path(storage_path) {
            // 设置文件夹权限
            umask(0);
            mkdir(storage_path.c_str(), 0775);
            
            // 确保路径以斜杠结尾
            if (_storage_path.back() != '/') _storage_path.push_back('/');
        }

        ~FileServiceImpl() {}

        // 获取单个文件的业务处理
        void GetSingleFile(google::protobuf::RpcController* controller,
                    const mag::GetSingleFileReq* request,
                    mag::GetSingleFileRsp* response,
                    google::protobuf::Closure* done) {
            brpc::ClosureGuard rpc_guard(done);
            response->set_request_id(request->request_id());

            // 1. 获取请求中的文件ID（即文件名）
            std::string fid = request->file_id();
            std::string filename = _storage_path + fid;

            // 2. 从存储路径读取文件数据
            std::string body;
            bool ret = readFile(filename, body);
            if (!ret) {
                response->set_success(false);
                response->set_errmsg("读取文件数据失败！");
                LOG_ERROR("{} 读取文件数据失败！", request->request_id());
                return;
            }

            // 3. 返回响应数据
            response->set_success(true);
            response->mutable_file_data()->set_file_id(fid);
            response->mutable_file_data()->set_file_content(body);
        }

        // 获取多个文件的业务处理
        void GetMultiFile(google::protobuf::RpcController* controller,
                    const mag::GetMultiFileReq* request,
                    mag::GetMultiFileRsp* response,
                    google::protobuf::Closure* done) {
            brpc::ClosureGuard rpc_guard(done);
            response->set_request_id(request->request_id());

            // 循环处理请求中的多个文件ID
            for (int i = 0; i < request->file_id_list_size(); i++) {
                std::string fid = request->file_id_list(i);
                std::string filename = _storage_path + fid;

                std::string body;
                bool ret = readFile(filename, body);
                if (!ret) {
                    response->set_success(false);
                    response->set_errmsg("读取文件数据失败！");
                    LOG_ERROR("{} 读取文件数据失败！", request->request_id());
                    return;
                }

                // 添加文件数据到响应
                mag::FileDownloadData data;
                data.set_file_id(fid);
                data.set_file_content(body);
                response->mutable_file_data()->insert({fid, data});
            }

            // 返回成功响应
            response->set_success(true);
        }

        // 上传单个文件的业务处理
        void PutSingleFile(google::protobuf::RpcController* controller,
                    const mag::PutSingleFileReq* request,
                    mag::PutSingleFileRsp* response,
                    google::protobuf::Closure* done) {
            brpc::ClosureGuard rpc_guard(done);
            response->set_request_id(request->request_id());

            // 1. 为文件生成唯一的文件ID（即 UUID）作为文件名
            std::string fid = uuid();
            std::string filename = _storage_path + fid;

            // 2. 获取请求中的文件数据并写入文件
            bool ret = writeFile(filename, request->file_data().file_content());
            if (!ret) {
                response->set_success(false);
                response->set_errmsg("写入文件数据失败！");
                LOG_ERROR("{} 写入文件数据失败！", request->request_id());
                return;
            }

            // 3. 返回文件信息
            response->set_success(true);
            response->mutable_file_info()->set_file_id(fid);
            response->mutable_file_info()->set_file_size(request->file_data().file_size());
            response->mutable_file_info()->set_file_name(request->file_data().file_name());
        }

        // 上传多个文件的业务处理
        void PutMultiFile(google::protobuf::RpcController* controller,
                    const mag::PutMultiFileReq* request,
                    mag::PutMultiFileRsp* response,
                    google::protobuf::Closure* done) {
            brpc::ClosureGuard rpc_guard(done);
            response->set_request_id(request->request_id());

            // 循环处理请求中的多个文件数据
            for (int i = 0; i < request->file_data_size(); i++) {
                std::string fid = uuid();
                std::string filename = _storage_path + fid;

                bool ret = writeFile(filename, request->file_data(i).file_content());
                if (!ret) {
                    response->set_success(false);
                    response->set_errmsg("写入文件数据失败！");
                    LOG_ERROR("{} 写入文件数据失败！", request->request_id());
                    return;
                }

                // 添加文件信息到响应
                mag::FileMessageInfo *info = response->add_file_info();
                info->set_file_id(fid);
                info->set_file_size(request->file_data(i).file_size());
                info->set_file_name(request->file_data(i).file_name());
            }

            // 返回成功响应
            response->set_success(true);
        }

    private:
        std::string _storage_path;  // 存储路径
};

// 文件存储服务类，负责启动和管理 RPC 服务
class FileServer {
    public:
        using ptr = std::shared_ptr<FileServer>;

        // 构造函数，接收服务注册客户端和 RPC 服务器
        FileServer(const Registry::ptr &reg_client,
            const std::shared_ptr<brpc::Server> &server):
            _reg_client(reg_client),
            _rpc_server(server) {}

        ~FileServer() {}

        // 启动 RPC 服务器，直到请求停止
        void start() {
            _rpc_server->RunUntilAskedToQuit();
        }

    private:
        Registry::ptr _reg_client;       // 服务注册客户端
        std::shared_ptr<brpc::Server> _rpc_server;  // RPC 服务器
};

// 文件存储服务构建者，用于构建文件存储服务
class FileServerBuilder {
    public:
        // 初始化服务注册客户端
        void make_reg_object(const std::string &reg_host,
            const std::string &service_name,
            const std::string &access_host) {
            _reg_client = std::make_shared<Registry>(reg_host);
            _reg_client->registry(service_name, access_host);
        }

        // 构建 RPC 服务器
        void make_rpc_server(uint16_t port, int32_t timeout, 
            uint8_t num_threads, const std::string &path = "./data/") {
            _rpc_server = std::make_shared<brpc::Server>();
            FileServiceImpl *file_service = new FileServiceImpl(path);

            // 注册文件服务到 RPC 服务器
            int ret = _rpc_server->AddService(file_service, 
                brpc::ServiceOwnership::SERVER_OWNS_SERVICE);
            if (ret == -1) {
                LOG_ERROR("添加Rpc服务失败！");
                abort();
            }

            brpc::ServerOptions options;
            options.idle_timeout_sec = timeout;
            options.num_threads = num_threads;

            // 启动 RPC 服务器
            ret = _rpc_server->Start(port, &options);
            if (ret == -1) {
                LOG_ERROR("服务启动失败！");
                abort();
            }
        }

        // 构建并返回文件服务器对象
        FileServer::ptr build() {
            if (!_reg_client) {
                LOG_ERROR("还未初始化服务注册模块！");
                abort();
            }
            if (!_rpc_server) {
                LOG_ERROR("还未初始化RPC服务器模块！");
                abort();
            }

            // 返回构建好的文件服务器对象
            return std::make_shared<FileServer>(_reg_client, _rpc_server);
        }

    private:
        Registry::ptr _reg_client;       // 服务注册客户端
        std::shared_ptr<brpc::Server> _rpc_server;  // RPC 服务器
};

}  // namespace mag
